/**
 * @(#)EmpleadosManagerK.java Jan 17, 2007
 *
 * Copyright (c) 2005-2010 Psiqueware S.A. de C.V. All Rights Reserved.
 * This software is the proprietary information Psiqueware S.A. de C.V.
 * Use is subject to license terms.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * <br/>Usuario : Psique
 * <br/>Creaci&oacute;n: Jan 17, 2007 - 3:32:16 PM
 * <br/>
 * <br/>
 * <br/><t5>Cambios :</t5>
 * <br/><b>Fecha | Autor  |  Cambios</b>
 * <ul>
 * <li>Jan 17, 2007 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Psique</a> | Creaci&oacute;n del Objeto.</li>
 * <li>Ene 25, 2007 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Psique</a> | Se corrigi&oacute; el problema de la transaccionalidad rota con las excepciones de precondici&oacute;n.</li>
 * <li>Ene 25, 2007 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Psique</a> | Se corrigi&oacute; el problema de la transaccionalidad rota con las excepciones de precondici&oacute;n.</li>
 * <li>Abr 19, 2007 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Psique</a> | Se eliminar&oacute;n las referencias a las clases Empresa, Deportamento, etc y se cambiar&oacute;n por referencias a Estructura.</li>
 * </ul>
 */

package com.psiqueware.jazmin.empresas.recursos.humanos.manager;

import com.psiqueware.alheli.exception.NullArgumentException;
import com.psiqueware.alheli.dao.EnlaceTransaccional;
import com.psiqueware.alheli.logging.Logger;
import com.psiqueware.alheli.logging.LoggerFactory;
import com.psiqueware.alheli.manager.BaseManager;
import com.psiqueware.alheli.manager.ManagerException;
import com.psiqueware.alheli.seguridad.Llave;
import com.psiqueware.alheli.seguridad.Modulo;
import com.psiqueware.alheli.seguridad.SeguridadException;
import com.psiqueware.alheli.seguridad.SeguridadManagerFactory;
import com.psiqueware.alheli.seguridad.UsuarioNoRegistradoException;
import com.psiqueware.alheli.seguridad.UsuariosSeguridadManager;
import com.psiqueware.jazmin.empresas.recursos.financieros.CentroCostos;
import com.psiqueware.jazmin.empresas.recursos.humanos.Asignacion;
import com.psiqueware.jazmin.empresas.recursos.humanos.Contrato;
import com.psiqueware.jazmin.empresas.recursos.humanos.Empleado;
import com.psiqueware.jazmin.empresas.recursos.humanos.EmpleadosManager;
import com.psiqueware.jazmin.empresas.recursos.humanos.EstatusLaboral;
import com.psiqueware.jazmin.empresas.recursos.humanos.RazonSueldo;
import com.psiqueware.jazmin.empresas.recursos.humanos.Sueldo;
import com.psiqueware.jazmin.empresas.recursos.humanos.dao.AsignacionDAO;
import com.psiqueware.jazmin.empresas.recursos.humanos.dao.ContratoDAO;
import com.psiqueware.jazmin.empresas.recursos.humanos.dao.EmpleadoDAO;
import com.psiqueware.jazmin.empresas.recursos.humanos.dao.RecursosHumanosDAOFactory;
import com.psiqueware.jazmin.empresas.recursos.humanos.dao.SueldoDAO;
import com.psiqueware.jazmin.empresas.recursos.humanos.modelo.AsignacionK;
import com.psiqueware.jazmin.empresas.recursos.humanos.modelo.ContratoK;
import com.psiqueware.jazmin.empresas.recursos.humanos.modelo.EmpleadoK;
import com.psiqueware.jazmin.empresas.recursos.humanos.modelo.SueldoK;
import com.psiqueware.jazmin.empresas.recursos.materiales.Ubicacion;
import com.psiqueware.tulipan.cargos.Cargo;
import com.psiqueware.tulipan.cargos.CargosManager;
import com.psiqueware.tulipan.cargos.CargosManagerFactory;
import com.psiqueware.tulipan.organizacional.Estructura;
import com.psiqueware.tulipan.personas.PersonaFisica;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Locale;

/**
 * Encargado de contratar empleados.
 * <br/>Paquete Original: com.psiqueware.tulipan.empresas.manager
 * <br/>Nombre  Original: ReclutamientoManagerK
 * <br/>Oprima para ver : <a href="EmpleadosManagerK.java.html"><i>C&oacute;digo Fuente</i> </a>
 *
 * @author <a href="mailto:AngelElectrico@PsiqueWare.com">Psique</a>
 * @version Revision: 1.1 Jan 17, 2007 3:32:16 PM
 * @noinspection CastToConcreteClass,DuplicateStringLiteralInspection,ClassWithoutToString,FeatureEnvy,OverlyCoupledMethod,OverlyCoupledClass
 */
public class EmpleadosManagerK extends BaseManager implements  Modulo, EmpleadosManager
{

    /** Logger de clase para EmpleadosManagerK */
    private static final Logger s_log = LoggerFactory.getLogger ( EmpleadosManagerK.class );


    /** DAO de {@link Empleado}. */
    private EmpleadoDAO m_empleadoDAO = RecursosHumanosDAOFactory.findDAOEmpleado ();

    /** DAO de {@link Sueldo}. */
    private SueldoDAO m_sueldoDAO = RecursosHumanosDAOFactory.findDAOSueldo ();

    /** DAO de {@link Contrato}. */
    private ContratoDAO m_contratoDAO = RecursosHumanosDAOFactory.findDAOContrato ();


    /** DAO de {@link Asignacion}. */
    private AsignacionDAO m_asignacionDAO = RecursosHumanosDAOFactory.findDAOAsignacion ();

    /** Control de Seguridad para este Reclutador. */
    private Llave m_llave;


    /** Manager de Seguridad para los Cargos. */
    private static UsuariosSeguridadManager s_UsuariosSeguridadManager = SeguridadManagerFactory.getUsuariosSeguridadManager ();

    /** Manager para asignar {@link Cargo}s. */
    private static CargosManager s_cargosManager = CargosManagerFactory.getCargosManager ();

    /** Constructor de EmpleadosManagerK. */
    public EmpleadosManagerK ()
    {
        try
        {
            SeguridadManagerFactory.getModulosManager ().registrarModulo ( this);
        }
        catch ( SeguridadException e )
        {
            final String error = "<error><msg>No se pudo registrar este M&oacute;dulo (EmpleadosManagerK) en la Seguridad.</msg></error>";
            s_log.error ( error );
            s_log.error ( e );
            throw new RuntimeException ( error, e );
        }
    }


    /**
     * Busca a todos los {@link Empleado}s para un {@link Departamento} y los lista.
     *
     * @param estructura        a donde pertenecen los {@link Empleado}s.
     * @param enlaceTransaccional para asegurar la atomicidad de la transacci&oacute;n.
     *
     * @return una {@link List} de {@link Empleado}; vacia en caso de no existir ninguno.
     *
     * @exception com.psiqueware.alheli.manager.ManagerException
     *             en caso de no poder completar la operaci&oacute;n.
     */
    public List<Empleado> buscarEmpleadosPorEstructura ( Estructura estructura, EnlaceTransaccional enlaceTransaccional ) throws ManagerException
    {

        try
        {
            if ( null == estructura ) throw new NullArgumentException ( "<error>El argumento 'estructura' no puede ser NULL.</error>" );
            if ( null == estructura.getId () ) throw new IllegalArgumentException ( "<error>El argumento 'estructura' deb&iacute;a encontrarse previamente persistido.</error>" );

            return m_empleadoDAO.findEmpleadoPorEstructura ( estructura, enlaceTransaccional );
        }
        catch ( Exception e )
        {
            final String error = "<error><msg>No se pudier&oacute;n listar los Empleados</msg><parametros>" + estructura + "</parametros></error>";
            s_log.error ( error );
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new ManagerException ( error, e );
        }
    }

    /**
     * Le asigna a un {@link Empleado} una {@link Ubicacion}, {@link CentroCostos} y {@link Departamento}.
     *
     * @param gerente             que realiza la asignaci&oacute;n. Debe tener su cargo inicializado; adem&aacute;s necesita permisos para la {@link Actividad} EmpleadosManagerK#s_liderearEmpleados.
     *                            Si la {@link Credencial} del {@link Cargo} no esta cargada ser&aacute; cargada por el m&eacute;todo.
     * @param empleado            que va a ser asignado. Necesita tener su cargo inicializado.
     *                            Si la {@link Credencial} del {@link Cargo} no esta cargada ser&aacute; cargada por el m&eacute;todo.
     * @param ubicacion           a donde se le va a asignar. No puede ser <code>null</code>.
     * @param centroCostos        a donde se va a cobrar el {@link Empleado}.
     * @param estructura        donde va a trabajar.
     * @param enlaceTransaccional para asegurar la atomicidad de la transacci&oacute;n.
     *
     * @return nueva {@link Asignacion}.
     *
     * @exception com.psiqueware.alheli.manager.ManagerException
     *             en caso de no poder completar la operaci&oacute;n.
     * @noinspection OverlyComplexMethod
     */
    public Asignacion asignarEmpleado ( Empleado gerente, Empleado empleado, Ubicacion ubicacion, CentroCostos centroCostos, Estructura estructura, EnlaceTransaccional enlaceTransaccional ) throws ManagerException
    {
        try
        {
            //validamos
            if ( null == gerente ) throw new NullArgumentException( "<error>El argumento 'gerente' no puede ser NULL.</error>" );
            if ( null == gerente.getId () ) throw new IllegalArgumentException ( "<error>El argumento 'gerente' deb&iacute;a encontrarse previamente persistido.</error>" );
            if ( null == gerente.getCargo () ) throw new NullArgumentException ( "<error>El argumento 'gerente.getCargo ()' no puede ser NULL.</error>" );
            if ( null == empleado ) throw new NullArgumentException ( "<error>El argumento 'empleado' no puede ser NULL.</error>" );
            if ( null == empleado.getId () ) throw new IllegalArgumentException ( "<error>El argumento 'empleado' deb&iacute;a encontrarse previamente persistido.</error>" );
            if ( null == empleado.getCargo () ) throw new NullArgumentException ( "<error>El argumento 'empleado.getCargo ()' no puede ser NULL.</error>" );
            if ( null == ubicacion ) throw new NullArgumentException ( "<error>El argumento 'ubicacion' no puede ser NULL.</error>" );
            if ( null == ubicacion.getId () ) throw new IllegalArgumentException ( "<error>El argumento 'ubicacion' deb&iacute;a encontrarse previamente persistido.</error>" );
            if ( null == centroCostos ) throw new NullArgumentException ( "<error>El argumento 'centroCostos' no puede ser NULL.</error>" );
            if ( null == centroCostos.getId () ) throw new IllegalArgumentException ( "<error>El argumento 'centroCostos' deb&iacute;a encontrarse previamente persistido.</error>" );
            if ( null == estructura ) throw new NullArgumentException ( "<error>El argumento 'estructura' no puede ser NULL.</error>" );
            if ( null == estructura.getId () ) throw new IllegalArgumentException ( "<error>El argumento 'estructura' deb&iacute;a encontrarse previamente persistido.</error>" );

            //inicializamos las credenciales de ser necesario
            if ( null == gerente.getCargo ().getCredencial () ) s_UsuariosSeguridadManager.iniciarSeguridadUsuario ( gerente.getCargo (), enlaceTransaccional );
            if ( null == empleado.getCargo ().getCredencial () ) s_UsuariosSeguridadManager.iniciarSeguridadUsuario ( empleado.getCargo (), enlaceTransaccional );

            AsignacionK salida = null;
            if ( m_llave.isHabilitadoActividad ( s_liderearEmpleados, gerente.getCargo () ) )
            {
                salida = new AsignacionK ( empleado, ubicacion, centroCostos, estructura );
                m_asignacionDAO.saveAsignacion ( salida, enlaceTransaccional );
            }
            return salida;
        }
        catch ( SeguridadException e )
        {
            final String error = "<error><msg>No se pudo cargar la Credencial del UsuarioSeguridad</msg><parametros></parametros></error>";
            s_log.error ( error );
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new ManagerException ( error, e, gerente );
        }
        catch ( UsuarioNoRegistradoException e )
        {
            final String error = "<error><msg>El Cargo no se encontraba registrado en la Seguridad de la Aplicaci&oacute;n.</msg><parametros>" + gerente + "</parametros></error>";
            s_log.error ( error );
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new RuntimeException ( error, e );
        }
        catch ( Exception e )
        {
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new ManagerException ( e.getLocalizedMessage (), e );
        }
    }

    /**
     * Le da un contrato a una {@link PersonaFisica} para que sea un {@link Empleado} de dicho {@link Departamento}.
     *
     * @param estructura        donde va a trabajar esta {@link Persona}. Debe encontrarse persistido.
     * @param trabajador          {@link PersonaFisica} que requiere el {@link Empleado}. Debe encontrarse persistida.
     * @param sueldo              {@link Sueldo} que se le va a pagar por el {@link Empleado}.
     * @param estatusLaboral      {@link EstatusLaboral} actual.
     * @param enlaceTransaccional para asegurar la atomicidad de la transacci&oacute;n.
     * @param contrato            acuerdo para el trabajador en su relaci&oacute;n con la Empresa.
     *
     * @return Empleado persistido con la informaci&oacute;n correcta.
     *
     * @exception com.psiqueware.alheli.manager.ManagerException
     *             en caso de no poder completar la operaci&oacute;n.
     * @noinspection MethodWithTooManyParameters,OverlyComplexMethod,OverlyLongMethod
     */
    public Empleado contratar ( Estructura estructura, PersonaFisica trabajador, Contrato contrato, Sueldo sueldo, EstatusLaboral estatusLaboral, EnlaceTransaccional enlaceTransaccional ) throws ManagerException
    {
        Empleado empleado = null;
        try
        {
            //validamos las entradas.
            if ( null == estructura ) throw new NullArgumentException ( "<error>El argumento 'estructura' no puede ser NULL.</error>" );
            if ( null == estructura.getId () ) throw new NullArgumentException ( "<error>El argumento 'estructura.getId ()' no puede ser NULL.</error>" );
            if ( null == trabajador ) throw new NullArgumentException ( "<error>El argumento 'trabajador' no puede ser NULL.</error>" );
            if ( null == trabajador.getId () ) throw new NullArgumentException ( "<error>El argumento 'trabajador.getId ()' no puede ser NULL.</error>" );
            if ( null == sueldo ) throw new NullArgumentException ( "<error>El argumento 'sueldo' no puede ser NULL.</error>" );
            if ( null == sueldo.getId () ) throw new NullArgumentException ( "<error>El argumento 'sueldo.getId ()' no puede ser NULL.</error>" );
            if ( null == estatusLaboral ) throw new NullArgumentException ( "<error>El argumento 'estatusLaboral' no puede ser NULL.</error>" );
            if ( null == estatusLaboral.getId () ) throw new NullArgumentException ( "<error>El argumento 'estatusLaboral.getId ()' no puede ser NULL.</error>" );
            if ( null == contrato ) throw new NullArgumentException ( "<error>El argumento 'contrato' no puede ser NULL.</error>" );
            if ( null == contrato.getId () ) throw new IllegalArgumentException ( "<error>El argumento 'contrato' deb&iacute;a encontrarse previamente persistido.</error>" );

            //creamos los objetos
            ContratoK contratoK = ( ContratoK ) contrato;
            contratoK.setSueldo ( sueldo );
            empleado = new EmpleadoK ( trabajador, contrato, estatusLaboral, estructura );

            //Guardamos el empleado.
            m_empleadoDAO.saveEmpleado ( empleado, enlaceTransaccional );
            m_contratoDAO.updateContrato ( contratoK, enlaceTransaccional );

            return empleado;
        }
        catch ( Exception e )
        {
            String error = "<error><msg>No se pudo contratar el Empleado.</msg><parametros>" + empleado + "</parametros></error>";
            s_log.error ( error );
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new ManagerException ( error, e );
        }
    }

    /**
     * Le asigna un {@link Cargo} a un {@link Empleado}.
     *
     * @param gerente             que autoriza la operaci&oacute;n.
     * @param empleado            al que se le va a asignar el {@link Cargo}. Debe encontrarse previamente persistido.
     * @param claveCargo          cadena con la clave para crear el {@link Cargo} que va a desempe&ntilde;ar este {@link Empleado}.
     * @param enlaceTransaccional para asegurar la atomicidad de la transacci&oacute;n.
     *
     * @return {@link Cargo} si puede crearlo; <code>null</code> en caso contrario.
     *
     * @exception com.psiqueware.alheli.manager.ManagerException
     *             en caso de no poder completar la operaci&oacute;n.
     * @noinspection BooleanMethodNameMustStartWithQuestion
     */
    public Cargo asignarCargo ( Empleado gerente, Empleado empleado, String claveCargo, EnlaceTransaccional enlaceTransaccional ) throws ManagerException
    {
        try
        {

            //validaciones
            if ( null == gerente ) throw new NullArgumentException ( "<error>El argumento 'gerente' no puede ser NULL.</error>" );
            if ( null == gerente.getId () ) throw new IllegalArgumentException ( "<error>El argumento 'gerente' deb&iacute;a encontrarse previamente persistido.</error>" );
            if ( null == empleado ) throw new NullArgumentException ( "<error>El argumento 'empleado' no puede ser NULL.</error>" );
            if ( null == empleado.getId () ) throw new NullArgumentException ( "<error>El argumento 'empleado' deb&iacute;a encontrarse previamente persistido.</error>" );
            if ( null == claveCargo ) throw new NullArgumentException ( "<error>El argumento 'claveCargo' no puede ser NULL.</error>" );

            Cargo salida = null;
            if ( m_llave.isHabilitadoActividad ( s_liderearEmpleados, gerente.getCargo () ) )
            {
                //creamos el cargo
                final Cargo cargo = s_cargosManager.subordinarCargo ( empleado, claveCargo, gerente.getCargo (), enlaceTransaccional );
                //lo guardamos.
                EmpleadoK empleoK = ( EmpleadoK ) empleado;
                empleoK.setCargo ( cargo );
                m_empleadoDAO.updateEmpleado ( empleoK, enlaceTransaccional );
                salida = cargo;
            }
            return salida;
        }
        catch ( Exception e )
        {
            String error = "<error><msg>No se pudo asignar el Cargo al Empleado.</msg><parametros>" + empleado + "</parametros></error>";
            s_log.error ( error );
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new ManagerException ( error, e );
        }
    }

    /**
     * Establece la fecha de baja de un {@link Empleado}.
     *
     * @param empleado            cuya fecha de baja se pretende establecer. Debe estar previamente persistido.
     * @param fechaBaja           fecha para la baja del empleado. No puede ser nula y debe ser mayor a su fecha de alta.
     * @param enlaceTransaccional para asegurar la atomicidad de la transacci&oacute;n.
     *
     * @exception com.psiqueware.alheli.manager.ManagerException
     *             en caso de no poder completar la operaci&oacute;n.
     */
    public void establecerFechaBajaEmpleo ( Empleado empleado, Date fechaBaja, EnlaceTransaccional enlaceTransaccional ) throws ManagerException
    {
        try
        {
            //validamos
            if ( null == empleado ) throw new NullArgumentException ( "<error>El argumento 'empleado' no puede ser NULL.</error>" );
            if ( null == empleado.getId () ) throw new NullArgumentException ( "<error>El argumento 'empleado' deb&iacute;a encontrarse previamente persistido.</error>" );
            if ( null == empleado.getContrato () ) throw new NullArgumentException ( "<error>El argumento 'empleado.getContrato ()' no puede ser NULL.</error>" );
            if ( null == fechaBaja ) throw new NullArgumentException ( "<error>El argumento 'fechaBaja' no puede ser NULL.</error>" );
            if ( !fechaBaja.after ( empleado.getContrato ().getFechaIngreso () ) ) throw new IllegalArgumentException ( "<error>El argumento 'fechaBaja' debe ser mayor que la 'fechaIngreso'.</error>" );

            //ponemos la fecha
            ContratoK contratoK = ( ContratoK ) empleado.getContrato ();
            contratoK.setFechaBaja ( fechaBaja );

            m_contratoDAO.updateContrato ( contratoK, enlaceTransaccional );
        }
        catch ( Exception e )
        {
            String error = "<error><msg>No se pudo actualizar la fecha de baja del empleado.</msg><parametros>" + empleado + "</parametros></error>";
            s_log.error ( error );
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new ManagerException ( error, e );
        }
    }

    /**
     * Aumenta (o disminuye) el {@link Sueldo} de un {@link Empleado}.
     * En caso de tenerse un {@link Sueldo} anterior este es eliminado.
     *
     * @param cantidad            a pagar por un mes de trabajo.
     * @param razonSueldo         raz&oacute;n por el aumento de sueldo. Puede ser <code>null</code>.
     * @param empleado            a quien se le va a aumentar el {@link Sueldo}. Ya estaba previamente persistido.
     * @param enlaceTransaccional para asegurar la atomicidad de la transacci&oacute;n.
     * @param locale              para posteriormente determinar la moneda.
     *
     * @exception com.psiqueware.alheli.manager.ManagerException
     *             en caso de no poder completar la operaci&oacute;n.
     * @noinspection FeatureEnvy
     */
    public void aumentarSueldo ( BigDecimal cantidad, RazonSueldo razonSueldo, Locale locale, Empleado empleado, EnlaceTransaccional enlaceTransaccional ) throws ManagerException
    {
        try
        {
            //validaciones
            if ( null == cantidad ) throw new NullArgumentException ( "<error>El argumento 'cantidad' no puede ser NULL.</error>" );
            if ( null == empleado ) throw new NullArgumentException ( "<error>El argumento 'empleado' no puede ser NULL.</error>" );
            if ( null == empleado.getId () ) throw new NullArgumentException ( "<error>El argumento 'empleado' deb&iacute;a encontrarse previamente persistido.</error>" );
            if ( null == empleado.getContrato () ) throw new NullArgumentException ( "<error>El argumento 'empleado.getContrato ()' no puede ser NULL.</error>" );
            if ( null == empleado.getContrato ().getSueldo () ) throw new NullArgumentException ( "<error>El argumento 'empleado.getContrato ().getSueldo ()' no puede ser NULL.</error>" );

            //Sueldo a eliminar
            final Sueldo eliminame = empleado.getContrato ().getSueldo ();
            //Nuevo Sueldo
            SueldoK sueldo = new SueldoK ( cantidad, razonSueldo, locale );
            m_sueldoDAO.saveSueldo ( sueldo, enlaceTransaccional );
            //Eliminamos el sueldo anterior en caso de tenerlo.
            if ( null != eliminame ) m_sueldoDAO.deleteSueldo ( eliminame, enlaceTransaccional );
            ContratoK contrato = ( ContratoK ) empleado.getContrato ();
            contrato.setSueldo ( sueldo );
            m_contratoDAO.updateContrato ( contrato, enlaceTransaccional );
        }
        catch ( Exception e )
        {
            String error = "<error><msg>No se pudo actualizar el sueldo del empleado.</msg><parametros>" + empleado + "</parametros></error>";
            s_log.error ( error );
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new ManagerException ( error, e );
        }
    }

    /**
     * Busca un {@link Empleado} en base a su id.
     *
     * @param idEmpleado          identificador &uacute;nico del {@link Empleado} buscado.
     * @param enlaceTransaccional para asegurar la atomicidad de la transacci&oacute;n.
     *
     * @return {@link Empleado} en caso de encontralo; <code>null</code> en caso contrario.
     *
     * @exception com.psiqueware.alheli.manager.ManagerException
     *             en caso de no poder completar la operaci&oacute;n.
     */
    public Empleado buscarEmpleadoPorId ( final Long idEmpleado, final EnlaceTransaccional enlaceTransaccional ) throws ManagerException
    {
        try
        {
            return m_empleadoDAO.findEmpleadoPorId ( idEmpleado, enlaceTransaccional );
        }
        catch ( Exception e )
        {
            final String error = "<error><msg>No se pudo buscar al Empleado.</msg><parametros>"+idEmpleado+"</parametros></error>";
            s_log.error ( error );
            s_log.error ( e );
            enlaceTransaccional.rollBack ();
            throw new ManagerException ( error, e );
        }
    }


    public void setLlave ( Llave llave )
    {

        m_llave = llave;
    }

    public Llave getLlave ()
    {
        return m_llave;
    }
}

